package hrx.service;

import hrx.dao.RelationDao;
import hrx.dao.TaskDao;
import hrx.dao.UserDao;
import hrx.entity.Relation;
import hrx.entity.Task;
import hrx.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.List;
import java.util.Optional;

@Service
public class XsdService {

    @Autowired
    private UserDao userDao;

    @Autowired
    private TaskDao taskDao;

    @Autowired
    private RelationDao relationDao;


    /**
     * 注册用户
     *
     * @param user
     */
    public void save(User user) {
        userDao.save(user);
    }

    /**
     * 登录验证
     *
     * @param user
     */
    public User findById(User user) {
        Optional<User> userOptional = userDao.findById(user.getUser_id()); // 假设是根据user_id查询
        if (userOptional.isPresent()) {
            return (User) userOptional.get(); // 有值才获取
        } else {
            // 没有找到用户时的处理，可返回null或抛出自定义异常
            return null;
            // 或者 throw new UserNotFoundException("用户不存在: " + userId);
        }
    }

    /**
     * 添加新任务
     *
     * @param task
     */
    public void saveTask(Task task) {
        taskDao.save(task);
    }

    /**
     * 查询所有任务
     *
     * @return
     */
    public List<Task> findAllTasks() {
        return taskDao.findAll();
    }

    /**
     * 删除任务
     *
     * @param
     */
    public void deleteTask(Integer id) {
        taskDao.deleteById(id);
    }

    /**
     * 查询任务
     *
     * @param id
     * @return
     */
    public Task findTaskById(Integer id) {
        Optional<Task> taskOptional = taskDao.findById(id);
        if (taskOptional.isPresent()) {
            return (Task) taskOptional.get();
        } else {
            return null;
        }
    }

    /**
     * 存储任务
     *
     * @param relation
     */
    public void save(Relation relation) {
        relationDao.save(relation);
    }

    /**
     * 根据用户id和任务id查询relation
     */
    public Relation findByUser_idAndTask_id(Relation relation) {
        // 假设根据用户ID和任务ID查询
        return relationDao.findByUserAndTask(relation.getUser_id(), relation.getTask_id());

    }

    /**
     * 根据user_id查询对应的user
     * @param user_id
     * @return
     */
    public User findByUser_id(Integer user_id) {
        Optional<User> byId = userDao.findById(user_id);
        if (byId.isPresent()) {
            return (User) byId.get();
        } else {
            return null;
        }
    }

    /**
     * 根据user_id查找对应的task
     *
     * @param user_id
     * @return
     */
    public List<Relation> findByUser_idRelation(Integer user_id) {
        return relationDao.findByUser_idRelation(user_id);
    }

    /**
     * 根据任务id查询对应的任务（列表）
     * @param taskIds
     * @return
     */
    public List<Task> findByIds(List<Integer> taskIds) {
        return taskDao.findByIdIn(taskIds);
    }

    /**
     * 根据条件搜索
     * @param school
     * @param status
     * @param priceMax
     * @param priceMin
     * @param words
     * @return
     */
    @Transactional(readOnly = true)  // 添加事务注解
    public List<Task> myFind(String school, Integer status, BigDecimal  priceMin, BigDecimal  priceMax, String words) {

        return taskDao.myFind(school,status,priceMin,priceMax,words);

    }

    /**
     * 查询所有用户信息
     * @return
     */
    public List<User> findAll() {
        return userDao.findAll();
    }

    /**
     * 根据任务id查找对应的任务
     * @param taskId
     * @return
     */
    public Relation findByRelation(Integer taskId) {
        return relationDao.findByRelation(taskId);
    }

    /**
     * 根据条件查询对应的任务
     * @param spec
     * @return
     */
    public List<Task> MyFindAll(Specification<Task> spec) {
        return taskDao.findAll(spec);
    }
}
